#pragma once
#include"HashTable.h"


namespace MyUDset {



	using namespace MyHashBucket;
	template<class T>
	class unordered_set {

		template<class T>
		struct KOfT {
			const T& operator()(const T& data)
			{
				return data;
			}
		};

	public:

		typedef typename hashTable< T, const T, KOfT<T> >::Iterator iterator;
		typedef typename hashTable< T, const T, KOfT<T> >::constIterator const_iterator;


		pair<iterator,bool> insert(const T& data)
		{
			return _hash.Insert(data);
		}
		void print()
		{
			_hash.Print();
		}
		int size()
		{
			return _hash.Size();
		}
		iterator find(const T& key)
		{
			return _hash.Find(key);
		}
		const_iterator find(const T& key) const
		{
			return _hash.Find(key);
		}
		bool erase(const T& key)
		{
			return _hash.Erase(key);
		}

		iterator begin()
		{
			return _hash.Begin();
		}
		iterator end()
		{
			return _hash.End();
		}
		const_iterator cbegin()
		{
			return _hash.cBegin();
		}
		const_iterator cend()
		{
			return _hash.cEnd();
		}
	private:

		hashTable<  T, const T, KOfT<T> > _hash;
	};

	void test1()
	{
		unordered_set<int> ust;

		ust.insert(13);
		ust.insert(133);
		ust.insert(1534);
		ust.insert(1135);
		ust.insert(6536);
		ust.insert(13453);
		ust.insert(132);
		ust.insert(136);
		ust.insert(1335);
		ust.insert(13778);
		ust.insert(1368);
		ust.insert(13368);
		ust.insert(15368);
		ust.insert(21368);
		ust.insert(41368);
		ust.insert(71368);


		ust.print();

		ust.erase(13);

		//*it = 5;
		ust.print();


		cout << ust.size() << endl;
	}
	void test2()
	{
		unordered_set<int> ust;

		ust.insert(13);
		ust.insert(133);
		ust.insert(1534);
		ust.insert(1135);
		ust.insert(6536);
		ust.insert(13453);
		ust.insert(132);
		ust.insert(136);
		ust.insert(1335);

		unordered_set<int>::const_iterator it = ust.cbegin();

		while(it != ust.cend())
		{
			//*it = 5;
			cout << *it << endl;
			//*it = 3;
			++it;
		}

	
		it = ust.cend();
	}

	
}